class Solution {

    //两个JDK提供的函数会让题解如此简单！以后记住这两个函数！
    // 1、charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
    // 2、Integer.parseInt(s) 或者 Integer.valueOf(s) 该方法正负均可转换！！！
    // 利用性质：
    // 字符串0到9的 ASCII 是 [48,57] 的闭区间。System.out.println((int)'0') 这条语句会输出48
    // 空格的ASCII是32
    public int myAtoi(String s) {
        //初步结果数组
        //firstResString 经过一次剔除算法，只包括符号和数字，其它的都不可能存在。
        StringBuilder firstResString = new StringBuilder();

        boolean flag =  true;   //结束遍历条件
        boolean backspace =  true;   //空格的校验.空格只有第一次
        //遍历
        for(int i = 0; i < s.length(); i++){
            //利用ASCII的性质, (int) s.charAt(i) 就是获取该字符的ASCII。
            int ascii = s.charAt(i);
            if (ascii == 32){   //是空格,，可以忽略
                if (!backspace){
                    break;  //空格校验未通过，说明该空格不是前导空格，直接返回！
                }
                continue;
            }else if (ascii >= 48 && ascii <= 57 || ascii == 45 || ascii == 43){
                //证明该字符一定是数字或者正符号，向字符串中追加。
                firstResString.append(s.charAt(i));
                //一旦发生追加操作，将不允许出现空格，将空格校验设为false
                backspace = false;
            }else {
                flag = false;   //除了正符号和空格和数字，直接判断为false
            }
            if (!flag){ //检测到flag为false 或者 空格校验也是false，就直接退出循环
                break;
            }
        }

        //第二次结果数组
        //这次的结果数组，已经非常接近成功，只需要专项处理前导零即可。
        // 比如像这样的数据，是处理不了的："  0000000000012345678",需要留待最后处理！
        StringBuilder secondResString = new StringBuilder();
        boolean isNegative =  true;   //符号的校验.符号只能出现一次，且这一次必须是数字的前面！
        boolean withoutDigit =  true;   //顾名思义，没有数字。没有数字天生为true

        //因为上面的清除，会将字符串和数字一视同仁。所以需要最后根据得到的字符串，专项清除符号。
        //firstResString 只包括符号和数字，其它的都不可能存在。
        for (int i = 0; i < firstResString.length(); i++) {
            int ascii = firstResString.charAt(i);
            //边界条件：开头就是一个符号，且length就是1  这种情况直接返回0
            if (firstResString.length() == 1 && ascii == 45 || firstResString.length() == 1 && ascii == 43){
                return 0;
            }
            //边界条件判断结束，正式开始走逻辑
            if (ascii == 45 || ascii == 43){
                if (!isNegative){   //第二次及以上次数出现符号，直接break
                    break;
                }
                if (isNegative){
                    secondResString.append(firstResString.charAt(i)); //该字符一定是最前导的符号，追加！
                    isNegative = false;
                }
            }else {
                secondResString.append(firstResString.charAt(i)); //该字符一定是数字，追加！
                withoutDigit = false;
                isNegative = false;     //保证数字统计开始了，符号会捣乱
            }
        }
        //遍历完成后，如果仍然没有任何数码，直接返回0即可
        if (withoutDigit){
            return 0;
        }

        //最终结果数组
        StringBuilder resString = new StringBuilder();
        boolean zeroJudge = true;   //0的判断条件
        boolean allZero =  true;   //顾名思义，全都是0，默认是true
        //专项清除前导0
        for (int i = 0; i < secondResString.length(); i++) {
            int ascii = secondResString.charAt(i);
            //边界条件，本身就是0，那么直接返回0
            if (secondResString.length() == 1 && ascii == 48){
                return 0;
            }
            //结束边界条件

            if (ascii == 48){
                if (zeroJudge)  //如果是前导0直接跳过
                    continue;
                if (!zeroJudge) //不是前导0继续追加
                    resString.append(secondResString.charAt(i));
            }else {
                resString.append(secondResString.charAt(i));
                zeroJudge = false;
                if (ascii == 45){
                    zeroJudge = true;   //仍然需要继续跳过
                }
                allZero = false;
            }

        }

        if (allZero){   //如果全都是0，直接return 0;
            return 0;
        }


        //边界检查：上界和下界必须在范围 [−2147483648, 2147483647] 之间。
        // long 取值范围在： -9223372036854775808到9223372036854775807 之间，所以long可以处理！
        // fucking 测试用例！  long 也处理不了！！！
        //string的位数大于11位，如果第一位是-，直接返回-2147483648，其它情况直接返回2147483647
        if (resString.length() > 11){
            if (resString.charAt(0) == 45){
                return -2147483648;
            }else {
                return 2147483647;
            }
        }
        if (String.valueOf(resString).equals("-") || String.valueOf(resString).equals("+")){
                return 0;
            }
        long l = Long.parseLong(String.valueOf(resString));
        if( l <= -2147483648){
            return -2147483648;
        }else if(l >= 2147483647) {
            return 2147483647;
        }

        return Integer.parseInt(String.valueOf(resString));
    }
}